{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "PI_DeepOnet_Eikonal_circle.ipynb",
   "provenance": [],
   "collapsed_sections": [],
   "machine_shape": "hm"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "accelerator": "GPU"
 },
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "id": "mRR_BT5vUnSw"
   },
   "source": [
    "import numpy as onp\n",
    "import jax.numpy as np\n",
    "from jax import random, grad, vmap, jit\n",
    "from jax.example_libraries import optimizers\n",
    "from jax.nn import relu\n",
    "from jax.config import config\n",
    "\n",
    "import itertools\n",
    "from functools import partial\n",
    "from torch.utils import data\n",
    "from tqdm import trange\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.interpolate import griddata\n",
    "\n",
    "%matplotlib inline"
   ],
   "execution_count": 1,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "rTZSJ2taqCPZ"
   },
   "source": [
    "# Define the neural net\n",
    "def MLP(layers, activation=relu):\n",
    "  ''' Vanilla MLP'''\n",
    "  def init(rng_key):\n",
    "      def init_layer(key, d_in, d_out):\n",
    "          k1, k2 = random.split(key)\n",
    "          glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
    "          W = glorot_stddev * random.normal(k1, (d_in, d_out))\n",
    "          b = np.zeros(d_out)\n",
    "          return W, b\n",
    "      key, *keys = random.split(rng_key, len(layers))\n",
    "      params = list(map(init_layer, keys, layers[:-1], layers[1:]))\n",
    "      return params\n",
    "  def apply(params, inputs):\n",
    "      for W, b in params[:-1]:\n",
    "          outputs = np.dot(inputs, W) + b\n",
    "          inputs = activation(outputs)\n",
    "      W, b = params[-1]\n",
    "      outputs = np.dot(inputs, W) + b\n",
    "      return outputs\n",
    "  return init, apply"
   ],
   "execution_count": 2,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "yPdIBu2xPoi4"
   },
   "source": [
    "class DataGenerator(data.Dataset):\n",
    "    def __init__(self, u, y, s, \n",
    "                 batch_size=64, rng_key=random.PRNGKey(1234)):\n",
    "        'Initialization'\n",
    "        self.u = u\n",
    "        self.y = y\n",
    "        self.s = s\n",
    "        \n",
    "        self.N = u.shape[0]\n",
    "        self.batch_size = batch_size\n",
    "        self.key = rng_key\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        'Generate one batch of data'\n",
    "        self.key, subkey = random.split(self.key)\n",
    "        inputs, outputs = self.__data_generation(subkey)\n",
    "        return inputs, outputs\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def __data_generation(self, key):\n",
    "        'Generates data containing batch_size samples'\n",
    "        idx = random.choice(key, self.N, (self.batch_size,), replace=False)\n",
    "        s = self.s[idx,:]\n",
    "        y = self.y[idx,:]\n",
    "        u = self.u[idx,:]\n",
    "        # Construct batch\n",
    "        inputs = (u, y)\n",
    "        outputs = s\n",
    "        return inputs, outputs\n"
   ],
   "execution_count": 3,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "kbh_Vdc8VmZZ"
   },
   "source": [
    "# Define the model\n",
    "class PI_DeepONet:\n",
    "    def __init__(self, branch_layers, trunk_layers):    \n",
    "        # Network initialization and evaluation functions\n",
    "        self.branch_init, self.branch_apply = MLP(branch_layers, activation=np.tanh)\n",
    "        self.trunk_init, self.trunk_apply = MLP(trunk_layers, activation=np.tanh)\n",
    "\n",
    "        # Initialize\n",
    "        branch_params = self.branch_init(rng_key = random.PRNGKey(1234))\n",
    "        trunk_params = self.trunk_init(rng_key = random.PRNGKey(4321))\n",
    "        params = (branch_params, trunk_params)\n",
    "\n",
    "        # Use optimizers to set optimizer initialization and update functions\n",
    "        self.opt_init, \\\n",
    "        self.opt_update, \\\n",
    "        self.get_params = optimizers.adam(optimizers.exponential_decay(1e-3, \n",
    "                                                                      decay_steps=1000, \n",
    "                                                                      decay_rate=0.9))\n",
    "        self.opt_state = self.opt_init(params)\n",
    "        self.itercount = itertools.count()\n",
    "\n",
    "        # Logger\n",
    "        self.loss_log = []\n",
    "        self.loss_bcs_log = []\n",
    "        self.loss_res_log = []\n",
    "\n",
    "    # Define DeepONet architecture\n",
    "    def operator_net(self, params, u, y1, y2):\n",
    "        y = np.stack([y1, y2])\n",
    "        branch_params, trunk_params = params\n",
    "        B = self.branch_apply(branch_params, u)\n",
    "        T = self.trunk_apply(trunk_params, y)\n",
    "        outputs = np.sum(B * T)\n",
    "        return outputs\n",
    "\n",
    "    # Define ODE/PDE residual\n",
    "    def residual_net(self, params, u, y1, y2):\n",
    "        s_y1 = grad(self.operator_net, argnums = 2)(params, u, y1, y2)\n",
    "        s_y2 = grad(self.operator_net, argnums = 3)(params, u, y1, y2)\n",
    "        res = s_y1**2 + s_y2**2\n",
    "        return res\n",
    "\n",
    "    # Define boundary loss\n",
    "    def loss_bcs(self, params, batch):\n",
    "        # Fetch data\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "        # Compute forward pass\n",
    "        pred = vmap(self.operator_net, (None, 0, 0, 0))(params, u, y[:,0], y[:,1])\n",
    "        # Compute loss\n",
    "        loss = np.mean((outputs.flatten() - pred.flatten())**2)\n",
    "        return loss\n",
    "\n",
    "    # Define residual loss\n",
    "    def loss_res(self, params, batch):\n",
    "        # Fetch data\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "        # Compute forward pass\n",
    "        pred = vmap(self.residual_net, (None, 0, 0, 0))(params, u, y[:,0], y[:, 1])\n",
    "        # Compute loss\n",
    "        loss = np.mean((pred - 1.0)**2)\n",
    "        return loss    \n",
    "    \n",
    "    # Define total loss\n",
    "    def loss(self, params, bcs_batch, res_batch):\n",
    "        loss_bcs = self.loss_bcs(params, bcs_batch)\n",
    "        loss_res = self.loss_res(params, res_batch)\n",
    "        loss = loss_bcs + loss_res\n",
    "        return loss\n",
    "\n",
    "    # Define a compiled update step\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def step(self, i, opt_state, bcs_batch, res_batch):\n",
    "        params = self.get_params(opt_state)\n",
    "        g = grad(self.loss)(params, bcs_batch, res_batch)\n",
    "        return self.opt_update(i, g, opt_state)\n",
    "\n",
    "    # Optimize parameters in a loop\n",
    "    def train(self, bcs_dataset, res_dataset, nIter = 10000):\n",
    "        bcs_data = iter(bcs_dataset)\n",
    "        res_data = iter(res_dataset)\n",
    "\n",
    "        pbar = trange(nIter)\n",
    "        # Main training loop\n",
    "        for it in pbar:\n",
    "            bcs_batch= next(bcs_data)\n",
    "            res_batch = next(res_data)\n",
    "\n",
    "            self.opt_state = self.step(next(self.itercount), self.opt_state, bcs_batch, res_batch)\n",
    "            \n",
    "            if it % 100 == 0:\n",
    "                params = self.get_params(self.opt_state)\n",
    "\n",
    "                # Compute losses\n",
    "                loss_value = self.loss(params, bcs_batch, res_batch)\n",
    "                loss_bcs_value = self.loss_bcs(params, bcs_batch)\n",
    "                loss_res_value = self.loss_res(params, res_batch)\n",
    "\n",
    "                # Store losses\n",
    "                self.loss_log.append(loss_value)\n",
    "                self.loss_bcs_log.append(loss_bcs_value)\n",
    "                self.loss_res_log.append(loss_res_value)\n",
    "\n",
    "                # Print losses\n",
    "                pbar.set_postfix({'Loss': loss_value, \n",
    "                                  'loss_bcs' : loss_bcs_value, \n",
    "                                  'loss_res': loss_res_value})\n",
    "       \n",
    "    # Evaluates predictions at test points  \n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_s(self, params, U_star, Y_star):\n",
    "        s_pred = vmap(self.operator_net, (None, 0, 0, 0))(params, U_star, Y_star[:,0], Y_star[:,1])\n",
    "        return s_pred"
   ],
   "execution_count": 4,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "k6NL6NI7P9Jo"
   },
   "source": [
    "# Geneate training data corresponding to zero boundary condition\n",
    "def generate_bcs_training_data(key, m=100, P=100):\n",
    "    # Sample a radius from an uniform distribution\n",
    "    r = random.uniform(key)\n",
    "    # Parameterzing the circle with polar coordinates\n",
    "    fn_theta = lambda theta:  np.hstack([r * np.cos(theta), r * np.sin(theta)])\n",
    "    # Discretize the parameter space \n",
    "    theta = np.linspace(0, 2 * np.pi, m)\n",
    "\n",
    "    # Input sample \n",
    "    u =  vmap(fn_theta)(theta).reshape(1, -1)  # shape = (1, 2m)   (x1, y1, x2, y2, ...) \n",
    "\n",
    "    # Fixed sensors\n",
    "    y1 = r * np.cos(theta)[:, None]\n",
    "    y2 = r * np.sin(theta)[:, None]\n",
    "    y =  np.hstack([y1, y2])  # shape = (m, 2)\n",
    "\n",
    "    # Tile inputs\n",
    "    u = np.tile(u, (P, 1))  # shape = (P, 2m) in this example P = m\n",
    "    s = np.zeros((P, 1))\n",
    "\n",
    "    return u, y, s \n",
    "\n",
    "# Geneate training data corresponding to PDE residual\n",
    "def generate_res_training_data(key, m=100, P=1000):\n",
    "    # Sample a radius from an uniform distribution\n",
    "    r = random.uniform(key)\n",
    "    # Parameterzing the circle with polar coordinates\n",
    "    fn_theta = lambda theta:  np.hstack([r * np.cos(theta), r * np.sin(theta)])\n",
    "    # Discretize the parameter space \n",
    "    theta = np.linspace(0, 2 * np.pi, m)\n",
    "\n",
    "    # Input sample \n",
    "    u =  vmap(fn_theta)(theta).reshape(1, -1)  # shape = (1, 2m)   (x1, y1, x2, y2, ...) \n",
    "    # Collocation points in [-1, 1] x [-1, 1]\n",
    "    y = - 1 + 2 * random.uniform(key, (P,2))\n",
    "    \n",
    "    # Tile inputs\n",
    "    u = np.tile(u, (P,1))  # shape = (P, 2m) \n",
    "    s = np.zeros((P, 1))\n",
    "\n",
    "    return u, y, s \n",
    "\n",
    "# Geneate test data \n",
    "def generate_test_data(key, m=100, P=100):\n",
    "    r = random.uniform(key)\n",
    "\n",
    "    fn_theta = lambda theta:  np.hstack([r * np.cos(theta), r * np.sin(theta)])\n",
    "\n",
    "    theta = np.linspace(0, 2 * np.pi, m)\n",
    "\n",
    "    u =  vmap(fn_theta)(theta).reshape(1, -1)  # shape = (1, 2m)   (x1, y1, x2, y2, ...) \n",
    "\n",
    "    y1 = np.linspace(-1,1, P)\n",
    "    y2 = np.linspace(-1,1, P)\n",
    "\n",
    "    y1, y2 = np.meshgrid(y1, y2)\n",
    "    y = np.hstack((y1.flatten()[:, None], y2.flatten()[:, None]))  # shape = (P, 2)\n",
    "\n",
    "    # Tile inputs\n",
    "    u = np.tile(u, (P**2, 1))  # shape = (P, 2m) in this example P = m\n",
    "\n",
    "    # Exact solution\n",
    "    def signed_dist(y1, y2):\n",
    "      dist = np.sqrt(y1**2 +y2**2) - r\n",
    "      return dist\n",
    "\n",
    "    s = signed_dist(y[:,0:1], y[:,1:2])\n",
    "    return r, u, y, s "
   ],
   "execution_count": 5,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "ZQ-HVgaQt0DO"
   },
   "source": [
    "\n",
    "# Training data for boundary loss\n",
    "N_train = 1000\n",
    "m = 100 # number of input sensors\n",
    "P_train = 100   # number of output sensors\n",
    "key = random.PRNGKey(0) # use different key for generating test data \n",
    "keys = random.split(key, N_train)\n",
    "gen_fn = jit(lambda key: generate_bcs_training_data(key, m, P_train))\n",
    "u_train, y_train, s_train = vmap(gen_fn)(keys)\n",
    "u_train = u_train.reshape(N_train * P_train,-1)\n",
    "y_train = y_train.reshape(N_train * P_train,-1)\n",
    "s_train = s_train.reshape(N_train * P_train,-1)\n",
    "\n",
    "\n",
    "# # Training data for residual loss\n",
    "m = 100 # number of input sensors\n",
    "P_r_train = 1000   # number of output sensors\n",
    "key = random.PRNGKey(0) # use different key for generating test data \n",
    "keys = random.split(key, N_train)\n",
    "gen_fn = jit(lambda key: generate_res_training_data(key, m, P_r_train))\n",
    "u_r_train, y_r_train, s_r_train = vmap(gen_fn)(keys)\n",
    "u_r_train = u_r_train.reshape(N_train * P_r_train,-1)\n",
    "y_r_train = y_r_train.reshape(N_train * P_r_train,-1)\n",
    "s_r_train = s_r_train.reshape(N_train * P_r_train,-1)"
   ],
   "execution_count": 6,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "3e0d9ay6he_Q"
   },
   "source": [
    "# Initialize model\n",
    "branch_layers = [2 * m, 50, 50, 50, 50, 50]\n",
    "trunk_layers =  [2, 50, 50, 50, 50, 50, 50]\n",
    "model = PI_DeepONet(branch_layers, trunk_layers)"
   ],
   "execution_count": 7,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "BmduhGwcHHXs"
   },
   "source": [
    "# Create data set\n",
    "batch_size = 10000\n",
    "bcs_dataset = DataGenerator(u_train, y_train, s_train, batch_size)\n",
    "res_dataset = DataGenerator(u_r_train, y_r_train, s_r_train, batch_size)"
   ],
   "execution_count": 8,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gW8Ej5Jvhf0r",
    "outputId": "0258e6a5-c51b-45ab-fc61-b6500e2cf41d"
   },
   "source": [
    "# Train\n",
    "model.train(bcs_dataset, res_dataset, nIter=40000)"
   ],
   "execution_count": 9,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "100%|██████████| 40000/40000 [11:05<00:00, 60.09it/s, Loss=0.00013336253, loss_bcs=2.081086e-06, loss_res=0.00013128144]\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 369
    },
    "id": "uhMrQopGN__b",
    "outputId": "1cfc864e-190e-421e-b0eb-c2e27433b08a"
   },
   "source": [
    "\n",
    "#Plot for loss function\n",
    "plt.figure(figsize = (6,5))\n",
    "# plt.plot(model.loss_log, lw=2)\n",
    "plt.plot(model.loss_bcs_log, lw=2, label='bcs')\n",
    "plt.plot(model.loss_res_log, lw=2, label='res')\n",
    "\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ],
   "execution_count": 10,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "t0bB2-o9KjV4",
    "outputId": "673d1945-6cb1-49bf-f5a2-dcc898e13de8"
   },
   "source": [
    "# Compute error\n",
    "N_test = 1000\n",
    "error = []\n",
    "P_test=100\n",
    "\n",
    "key_test = random.PRNGKey(12345)  # use different key for generating test data \n",
    "keys_test = random.split(key_test, N_test)\n",
    "\n",
    "params = model.get_params(model.opt_state)\n",
    "\n",
    "for k in range(N_test):\n",
    "  if k % 100 == 0:\n",
    "    print(k)\n",
    "  r_test, u_test, y_test, s_test = generate_test_data(keys_test[k], m, P=100)\n",
    "  u_test = np.float32(u_test.reshape(1 * P_test**2,-1))\n",
    "  y_test = np.float32(y_test.reshape(1 * P_test**2,-1))\n",
    "  s_test = np.float32(s_test.reshape(1 * P_test**2,-1))\n",
    "\n",
    "  s_pred = model.predict_s(params, u_test, y_test)[:,None]\n",
    "  error_s = np.linalg.norm(s_test - s_pred) / np.linalg.norm(s_test) \n",
    "\n",
    "  error.append(error_s)\n"
   ],
   "execution_count": 11,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "0\n",
      "100\n",
      "200\n",
      "300\n",
      "400\n",
      "500\n",
      "600\n",
      "700\n",
      "800\n",
      "900\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "mAPsjb5QNlbn",
    "outputId": "2b5a3013-74cb-4165-a700-70e223ed208c"
   },
   "source": [
    "error_s = np.array(error)\n",
    "print('mean of relative L2 error of s: {:.2e}'.format(error_s.mean()))\n",
    "print('std of relative L2 error of s: {:.2e}'.format(error_s.std()))"
   ],
   "execution_count": 12,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "mean of relative L2 error of s: 2.81e-03\n",
      "std of relative L2 error of s: 9.18e-04\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 386
    },
    "id": "NicghBbsmLUH",
    "outputId": "3be5f617-c9de-4755-b70d-3fe31739cc80"
   },
   "source": [
    "# Test data\n",
    "N_test = 100\n",
    "m = 100   # number of input sensors (needs to be the same as above!)\n",
    "P_test = 10000   # number of output sensors\n",
    "key = random.PRNGKey(1234567)  # use different key for generating test data \n",
    "keys = random.split(key, N_test)\n",
    "gen_fn = jit(lambda key: generate_test_data(key, m, P=100))\n",
    "r_test, u_test, y_test, s_test = vmap(gen_fn)(keys)\n",
    "\n",
    "u_test = np.float32(u_test.reshape(N_test * P_test,-1))\n",
    "y_test = np.float32(y_test.reshape(N_test * P_test,-1))\n",
    "s_test = np.float32(s_test.reshape(N_test * P_test,-1))\n",
    "\n",
    "s_pred = model.predict_s(params, u_test, y_test)[:,None]\n",
    "\n",
    "# Plot for one generated data\n",
    "idx = 1\n",
    "index = np.arange(idx * P_test,(idx + 1) * P_test)\n",
    "\n",
    "theta = np.linspace(0, 2* np.pi, 100)\n",
    "\n",
    "u1 = r_test[idx] * np.cos(theta)[:, None]\n",
    "u2 = r_test[idx] * np.sin(theta)[:, None]\n",
    "\n",
    "error_s = np.linalg.norm(s_test[index, :] - s_pred[index, :]) / np.linalg.norm(s_test[index, :]) \n",
    "\n",
    "print(\"error_s: {:.3e}\".format(error_s))\n",
    "\n",
    "y1 = np.linspace(-1,1, 100)\n",
    "y2 = np.linspace(-1,1, 100)\n",
    "\n",
    "y1, y2 = np.meshgrid(y1, y2)\n",
    "y_star = np.hstack((y1.flatten()[:, None], y2.flatten()[:, None]))\n",
    "\n",
    "S_star = griddata(y_star, s_test[index, :].flatten(), (y1, y2), method='cubic')\n",
    "S_pred = griddata(y_star, s_pred[index, :].flatten(), (y1, y2), method='cubic')\n",
    "\n",
    "plt.figure(figsize=(18,5))\n",
    "plt.subplot(1,3,1)\n",
    "plt.pcolor(y1, y2, S_star, cmap='bwr')\n",
    "plt.plot(u1, u2, '.', color='black')\n",
    "plt.title('Exact')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.colorbar()\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(1,3,2)\n",
    "plt.pcolor(y1, y2, S_pred, cmap='bwr')\n",
    "plt.colorbar()\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('Predict')\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(1,3,3)\n",
    "plt.pcolor(y1, y2, np.abs(S_pred- S_star), cmap='bwr')\n",
    "plt.colorbar()\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('Absolute error')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 13,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "error_s: 1.932e-03\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x360 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ]
  }
 ]
}
